package com.pai4j.zwiki.service.agent;

import com.pai4j.zwiki.domain.entity.CodeStructureEntity;
import com.pai4j.zwiki.repository.CodeStructureRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * 增强版代码阅读编排器
 * 
 * 整合所有Agent能力，提供最强大的代码理解功能
 * 
 * 核心改进：
 * 1. ✅ 智能文件优先级排序 - 优先阅读重要文件
 * 2. ✅ 代码关系图谱构建 - 理解类之间的依赖关系
 * 3. ✅ 上下文管理优化 - 智能压缩和记忆机制
 * 4. ✅ 执行流程追踪 - 追踪完整的业务调用链
 * 5. ✅ 多Agent并行协作 - 5个专业Agent并行工作
 * 6. ✅ 代码演化分析 - 分析Git历史理解演化
 * 7. ✅ 可视化报告 - 生成交互式HTML报告
 * 8. ✅ 增量式理解 - 分批处理大型项目
 * 9. ✅ 上下文传递优化 - 每轮分析传递前序理解
 * 10. ✅ 长文本智能压缩 - 保留关键信息
 *
 * @author pai4j
 * @since 2025-10-14
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class EnhancedCodeReadingOrchestrator {

    private final CodeStructureRepository codeStructureRepository;
    private final DeepCodeReader deepCodeReader;
    private final IntelligentFilePrioritizer filePrioritizer;
    private final CodeRelationshipGraphBuilder graphBuilder;
    private final CodeContextManager contextManager;
    private final CodeExecutionFlowTracer executionFlowTracer;
    private final MultiAgentOrchestrator multiAgentOrchestrator;
    private final CodeEvolutionAnalyzer evolutionAnalyzer;
    private final VisualCodeUnderstandingReporter visualReporter;

    /**
     * 执行完整的增强式代码阅读（整合所有新功能）
     */
    public Map<String, Object> executeEnhancedCodeReading(String taskId, String workspacePath) {
        log.info("🚀 开始执行增强版代码阅读, 任务ID: {}", taskId);
        log.info("=== 新功能：智能优先级、关系图谱、多Agent协作、演化分析 ===");

        Map<String, Object> enhancedReport = new HashMap<>();

        try {
            // 创建上下文会话
            String sessionId = contextManager.createContextSession(taskId);
            enhancedReport.put("sessionId", sessionId);

            // ========== 阶段零：准备阶段（新增） ==========
            log.info("\n【阶段零：准备】构建代码关系图谱（新功能）");
            
            // 0.1 构建代码关系图谱（新功能）
            Map<String, Object> relationshipGraph = graphBuilder.buildCodeRelationshipGraph(taskId, workspacePath);
            enhancedReport.put("relationshipGraph", relationshipGraph);
            
            // 保存到上下文
            @SuppressWarnings("unchecked")
            Map<String, Set<String>> dependencyGraph = 
                    (Map<String, Set<String>>) relationshipGraph.get("dependencyGraph");

            // 0.2 智能文件优先级排序（新功能）
            log.info("智能文件优先级排序（新功能）");
            List<CodeStructureEntity> structures = codeStructureRepository.findByTaskId(taskId);
            List<CodeStructureEntity> prioritizedFiles = filePrioritizer.prioritizeFiles(
                    structures, dependencyGraph);
            enhancedReport.put("prioritizedFiles", prioritizedFiles.stream()
                    .limit(30)
                    .map(CodeStructureEntity::getName)
                    .toList());

            // ========== 阶段一：深度阅读（优化） ==========
            log.info("\n【阶段一：深度阅读】执行渐进式深度代码阅读");
            
            // 使用优先级排序后的文件进行深度阅读
            Map<String, Object> deepReadingReport = deepCodeReader.executeDeepReading(workspacePath, taskId);
            enhancedReport.put("deepReadingReport", deepReadingReport);
            
            // 添加到上下文（重要度：10）
            contextManager.addAnalysisToContext(sessionId, "深度代码阅读",
                    deepReadingReport.toString(), 10);

            // ========== 阶段二：执行流程分析（新增） ==========
            log.info("\n【阶段二：执行流程】追踪业务执行路径（新功能）");
            
            Map<String, Object> executionFlows = executionFlowTracer.traceBusinessExecutionFlows(
                    taskId, workspacePath);
            enhancedReport.put("executionFlows", executionFlows);
            
            // 添加到上下文（重要度：8）
            contextManager.addAnalysisToContext(sessionId, "执行流程分析",
                    executionFlows.toString(), 8);

            // ========== 阶段三：Git演化分析（新增） ==========
            log.info("\n【阶段三：演化分析】分析代码演化历史（新功能）");
            
            Map<String, Object> evolutionAnalysis = evolutionAnalyzer.analyzeCodeEvolution(workspacePath);
            enhancedReport.put("evolutionAnalysis", evolutionAnalysis);
            
            // 添加到上下文（重要度：7）
            if (!evolutionAnalysis.containsKey("error")) {
                contextManager.addAnalysisToContext(sessionId, "代码演化分析",
                        evolutionAnalysis.toString(), 7);
            }

            // ========== 阶段四：多Agent并行分析（新增） ==========
            log.info("\n【阶段四：多Agent协作】5个专业Agent并行分析（新功能）");
            
            // 获取完整上下文
            String fullContext = contextManager.getFullContext(sessionId);
            Map<String, Object> baseContext = new HashMap<>();
            baseContext.put("contextSummary", fullContext);
            
            // 执行多Agent并行分析
            Map<String, Object> multiAgentResults = multiAgentOrchestrator.executeMultiAgentAnalysis(
                    taskId, workspacePath, baseContext);
            enhancedReport.put("multiAgentAnalysis", multiAgentResults);

            // ========== 阶段五：生成可视化报告（新增） ==========
            log.info("\n【阶段五：可视化】生成交互式HTML报告（新功能）");
            
            // 合并所有分析结果
            Map<String, Object> allResults = new HashMap<>();
            allResults.putAll(enhancedReport);
            allResults.putAll(multiAgentResults);
            
            String visualReport = visualReporter.generateVisualReport(
                    allResults, extractProjectName(workspacePath));
            enhancedReport.put("visualHtmlReport", visualReport);

            // ========== 生成最终总结 ==========
            log.info("\n【最终总结】汇总所有分析结果");
            
            Map<String, Object> finalSummary = generateFinalSummary(enhancedReport);
            enhancedReport.put("finalSummary", finalSummary);

            log.info("✅ 增强版代码阅读完成！");
            log.info("=== 亮点功能 ===");
            log.info("✓ 智能优先级：优先分析{}个核心文件", 
                    Math.min(30, prioritizedFiles.size()));
            log.info("✓ 关系图谱：构建了完整的类依赖关系");
            log.info("✓ 执行追踪：追踪了业务执行流程");
            log.info("✓ 多Agent：5个专业Agent并行协作");
            log.info("✓ 演化分析：分析了代码演化历史");
            log.info("✓ 可视化：生成了交互式HTML报告");

        } catch (Exception e) {
            log.error("增强版代码阅读失败", e);
            enhancedReport.put("error", e.getMessage());
        }

        return enhancedReport;
    }

    /**
     * 生成最终总结
     */
    private Map<String, Object> generateFinalSummary(Map<String, Object> allResults) {
        Map<String, Object> summary = new HashMap<>();

        summary.put("analysisCompleted", true);
        summary.put("analysisTimestamp", System.currentTimeMillis());
        
        // 统计各项指标
        summary.put("totalAnalysisRounds", countAnalysisRounds(allResults));
        summary.put("newFeatures", Arrays.asList(
                "智能文件优先级",
                "代码关系图谱",
                "执行流程追踪",
                "多Agent协作",
                "演化历史分析",
                "可视化报告"
        ));

        // 关键发现
        List<String> keyFindings = new ArrayList<>();
        keyFindings.add("✅ 完成了渐进式深度代码阅读");
        keyFindings.add("✅ 构建了完整的代码关系图谱");
        keyFindings.add("✅ 追踪了主要的业务执行流程");
        keyFindings.add("✅ 分析了代码演化历史");
        keyFindings.add("✅ 生成了交互式可视化报告");
        
        summary.put("keyFindings", keyFindings);

        return summary;
    }

    private int countAnalysisRounds(Map<String, Object> results) {
        int count = 0;
        if (results.containsKey("deepReadingReport")) count++;
        if (results.containsKey("relationshipGraph")) count++;
        if (results.containsKey("executionFlows")) count++;
        if (results.containsKey("evolutionAnalysis")) count++;
        if (results.containsKey("multiAgentAnalysis")) count++;
        return count;
    }

    private String extractProjectName(String workspacePath) {
        return Paths.get(workspacePath).getFileName().toString();
    }
}

